Aula: PrismaJS + NestJS + SQLite

Criando uma API moderna e tipada com ORM

Objetivos da Aula

• Entender o que é o Prisma ORM
• Aprender a instalar e configurar o Prisma em um projeto NestJS
• Utilizar o SQLite como banco de dados local
• Criar modelos, migrar o banco e usar o Prisma Client
• Integrar o Prisma a um módulo do NestJS

O que é o Prisma?

O Prisma é um ORM (Object Relational Mapper) moderno para Node.js e TypeScript.

Ele substitui ORMs tradicionais (como TypeORM e Sequelize) oferecendo:

• Autocompletar e tipagem forte (Typescript)
• Gerador de cliente automático
• Migrações simples e seguras
• Suporte a vários bancos (Postgres, MySQL, SQLite, etc.)

Arquitetura Geral

NestJS (Controllers, Services)
       ↓
   Prisma Service
       ↓
   Prisma Client
       ↓
   Banco de Dados (SQLite)

Passo 1 — Criar o Projeto NestJS

npm i -g @nestjs/cli
nest new api-prisma
cd api-prisma

Escolha npm ou yarn conforme sua preferência.

Passo 2 — Instalar o Prisma

npm install prisma --save-dev
npm install @prisma/client

Inicializar o Prisma:

npx prisma init

Isso cria a pasta prisma/ com o arquivo schema.prisma e adiciona o .env.

Passo 3 — Configurar o Banco de Dados (SQLite)

No arquivo .env:

DATABASE_URL="file:./dev.db"

No prisma/schema.prisma:

generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider = "sqlite"
  url      = env("DATABASE_URL")
}

Passo 4 — Criar um Modelo

Vamos criar uma tabela de usuários:

model User {
  id        Int      @id @default(autoincrement())
  name      String
  email     String   @unique
  createdAt DateTime @default(now())
}

Passo 5 — Gerar o Banco e o Cliente

Rodar as migrações:

npx prisma migrate dev --name init

Verifique o banco com:

npx prisma studio

(Abre uma interface web de visualização dos dados)

Passo 6 — Criar o PrismaModule no NestJS

Crie o arquivo:
src/prisma/prisma.module.ts

import { Global, Module } from '@nestjs/common';
import { PrismaService } from './prisma.service';

@Global()
@Module({
  providers: [PrismaService],
  exports: [PrismaService],
})
export class PrismaModule {}

PrismaService

Crie o arquivo:
src/prisma/prisma.service.ts

import { Injectable, OnModuleInit, OnModuleDestroy } from '@nestjs/common';
import { PrismaClient } from '@prisma/client';

@Injectable()
export class PrismaService extends PrismaClient
  implements OnModuleInit, OnModuleDestroy {
  async onModuleInit() {
    await this.$connect();
  }

  async onModuleDestroy() {
    await this.$disconnect();
  }
}

Passo 7 — Criar o Módulo de Usuários

nest g module users
nest g service users
nest g controller users

UserService com Prisma

src/users/users.service.ts

import { Injectable } from '@nestjs/common';
import { PrismaService } from '../prisma/prisma.service';
import { User } from '@prisma/client';

@Injectable()
export class UsersService {
  constructor(private prisma: PrismaService) {}

  async create(name: string, email: string): Promise<User> {
    return this.prisma.user.create({
      data: { name, email },
    });
  }

  async findAll(): Promise<User[]> {
    return this.prisma.user.findMany();
  }
}

UsersController

src/users/users.controller.ts

import { Controller, Get, Post, Body } from '@nestjs/common';
import { UsersService } from './users.service';

@Controller('users')
export class UsersController {
  constructor(private readonly usersService: UsersService) {}

  @Get()
  findAll() {
    return this.usersService.findAll();
  }

  @Post()
  create(@Body() body: { name: string; email: string }) {
    return this.usersService.create(body.name, body.email);
  }
}

Passo 8 — Registrar o PrismaModule

src/app.module.ts

import { Module } from '@nestjs/common';
import { UsersModule } from './users/users.module';
import { PrismaModule } from './prisma/prisma.module';

@Module({
  imports: [PrismaModule, UsersModule],
})
export class AppModule {}

Testando a API

Rodar o servidor:

npm run start:dev

Endpoints:

• GET /users → lista usuários
• POST /users → cria usuário

Exemplo de corpo JSON:

{
  "name": "Alice",
  "email": "alice@email.com"
}

Resultado Esperado

POST /users
→ { id: 1, name: "Alice", email: "...", createdAt: "..." }

GET /users
→ [ { id: 1, name: "Alice", ... } ]

Recapitulando

1. Criamos um projeto NestJS
2. Instalamos e configuramos o Prisma ORM
3. Usamos SQLite como banco
4. Criamos modelos e migramos o banco
5. Implementamos PrismaService
6. Fizemos CRUD básico no módulo de usuários

Dica Extra: Prisma Studio

Para visualizar o banco:

npx prisma studio

Interface web incrível para editar e visualizar dados.

Conclusão

O Prisma simplifica o acesso ao banco, garantindo tipagem, produtividade e segurança.
Com o NestJS, formamos uma combinação poderosa para APIs modernas e escaláveis

Referências

• Prisma Docs
• NestJS Docs
• SQLite Docs